.TH std::common_comparison_category 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::common_comparison_category \- std::common_comparison_category

.SH Synopsis
   Defined in header <compare>
   template< class... Ts >

   struct common_comparison_category
   {                                   \fI(since C++20)\fP
       using type = /* see below */ ;

   };

   The class template std::common_comparison_category provides an alias (as the member
   typedef type) for the strongest comparison category to which all of the template
   arguments Ts... can be converted.

   In detail, the common comparison type of a list of n types T[0]...T[n-1] is defined
   as follows:

     * If any T[i] is not a comparison category type (std::partial_ordering,
       std::weak_ordering, std::strong_ordering), U is void.
     * Otherwise, if at least one T[i] is std::partial_ordering, U is
       std::partial_ordering.
     * Otherwise, if at least one T[i] is std::weak_ordering, U is std::weak_ordering.
     * Otherwise (if every T[i] is std::strong_ordering, or if the list is empty), U is
       std::strong_ordering.

.SH Template parameters

   ...Ts - a possibly empty list of types

   Helper template

   template< class... Ts >
   using common_comparison_category_t =                                   \fI(since C++20)\fP
   common_comparison_category<Ts...>::type;

.SH Member types

   Member type Definition
   type        the strongest common comparison category (as defined above)

.SH Possible implementation

   namespace detail
   {
       template<unsigned int>
       struct common_cmpcat_base     { using type = void; };
       template<>
       struct common_cmpcat_base<0u> { using type = std::strong_ordering; };
       template<>
       struct common_cmpcat_base<2u> { using type = std::partial_ordering; };
       template<>
       struct common_cmpcat_base<4u> { using type = std::weak_ordering; };
       template<>
       struct common_cmpcat_base<6u> { using type = std::partial_ordering; };
   } // namespace detail

   template<class...Ts>
   struct common_comparison_category :
       detail::common_cmpcat_base<(0u | ... |
           (std::is_same_v<Ts, std::strong_ordering>  ? 0u :
            std::is_same_v<Ts, std::weak_ordering>    ? 4u :
            std::is_same_v<Ts, std::partial_ordering> ? 2u : 1u)
       )> {};

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   strong_ordering  the result type of 3-way comparison that supports all 6 operators
   (C++20)          and is substitutable
                    \fI(class)\fP
   weak_ordering    the result type of 3-way comparison that supports all 6 operators
   (C++20)          and is not substitutable
                    \fI(class)\fP
   partial_ordering the result type of 3-way comparison that supports all 6 operators,
   (C++20)          is not substitutable, and allows incomparable values
                    \fI(class)\fP

.SH Category:
     * Todo no example
